import * as PIXI from "pixi.js";

export default function PixiMap() {
  let app;
  const pixiMap = {};
  pixiMap.mode = "loop";
  pixiMap.lineSize = 0.05; // 绘制的路线的线宽
  pixiMap.lineColor = "0x1B9AF7"; // 绘制路线的颜色
  pixiMap.pointSize = 0.5; // 绘制点位的大小
  pixiMap.wallSize = 0.05; // 绘制虚拟墙的宽度
  pixiMap.wallColor = "0xFF0000"; // 绘制虚拟墙的颜色
  pixiMap.scanColor = "0x6600FF"; // 绘制激光雷达的颜色
  pixiMap.dotList = []; // 储存多边形的点对象
  pixiMap.path = []; // 储存多边形画线坐标
  pixiMap.duobian = new PIXI.Graphics(); // 提前创建一个多边形线
  pixiMap.activeIndex = 0; // 索引
  pixiMap.linesList = []; // 编辑时需要隐藏的线
  pixiMap.distance = 0; // 储存第一次双指之间的距离
  pixiMap.centerPos = null; // 储存第一次双指之间的中点
  pixiMap.mouseover = false; // 鼠标是否悬停在地图上
  pixiMap.stageMove = false; // 舞台拖动
  pixiMap.mapFormat = "png"; // 地图类型

  window.addEventListener(
    "touchstart",
    function (e) {
      const evt = e || window.event; // 考虑兼容性
      // 双指触摸时
      if (evt.touches.length === 2) {
        // 地图拖动关闭
        pixiMap.stageMove = false;
        // 记录首次双指距离
        pixiMap.distance = getDistance(evt.touches[0], evt.touches[1]);
        // 记录首次双指中心
        pixiMap.centerPos = {
          x: (evt.touches[0].clientX + evt.touches[1].clientX) / 2,
          y: (evt.touches[0].clientY + evt.touches[1].clientY) / 2,
        };
      }
    },
    {
      passive: false,
    }
  );

  window.addEventListener(
    "touchmove",
    function (e) {
      const evt = e || window.event; // 考虑兼容性
      if (evt.touches.length === 2) {
        pixiMap.stageMove = false;
        // 判断距离是否需要重新计算距离
        if (pixiMap.distance === 0) {
          pixiMap.distance = getDistance(evt.touches[0], evt.touches[1]);
        }
        // 判断2个点之间距离-第一次点距离是否大于等于10
        if (
          getDistance(evt.touches[0], evt.touches[1]) - pixiMap.distance >
          10
        ) {
          // 对中心点放大
          pixiMap.zoom(0.5, pixiMap.centerPos.x, pixiMap.centerPos.y);
          // 触发放大后重新计算双指滑动距离
          pixiMap.distance = 0;
        } else if (
          pixiMap.distance - getDistance(evt.touches[0], evt.touches[1]) >
          10
        ) {
          // 对中心点缩小
          pixiMap.zoom(-0.5, pixiMap.centerPos.x, pixiMap.centerPos.y);
          // 触发缩小后重新计算双指滑动距离
          pixiMap.distance = 0;
        }
      }
    },
    {
      passive: false,
    }
  );

  /**
   * 创建舞台
   * @param options ：
   *    * div - canvas的父类div
   *    * width - canvas宽
   *    * height - canvas高
   * @returns {PIXI.Container|number|null|*} pixijs的舞台元素，即根级父类容器
   * @constructor
   */
  pixiMap.createStage = (options) => {
    options = options || {};
    const div = options.div;
    const width = options.width;
    const height = options.height;
    app = new PIXI.Application({
      width,
      height,
      antialias: true,
      resizeTo: options.div,
    });
    // 渲染canvas
    div.appendChild(app.view);
    // 改变Y轴中心
    app.stage.y = height;
    // 启用事件
    app.stage.interactive = true;
    let startPointX, startPointY;
    app.stage.on("mouseover", () => {
      pixiMap.mouseover = true;
    });
    app.stage.on("mouseout", () => {
      pixiMap.mouseover = false;
    });
    app.stage.on("pointerdown", (e) => {
      const timeInterval = new Date().getTime();
      // 视角未锁定，记录点击位置，用于拖动镜头
      if (!pixiMap.viewLocking) {
        pixiMap.stageMove = true;
        startPointX = app.stage.x - e.data.global.x;
        startPointY = app.stage.y - e.data.global.y;
      }
      // 机器人重定位开启中
      if (pixiMap.changeLocation) {
        if (pixiMap.lastClick) {
          if (timeInterval - pixiMap.lastClick < 500) {
            // 双击时间小于500毫秒 触发
            pixiMap.changePose(
              pixiMap.globalToRos(e.data.global.x, e.data.global.y)
            );
          }
        }
        pixiMap.lastClick = timeInterval;
      }
      // 机器人重定方向开启中
      if (pixiMap.changeDirection) {
        pixiMap.changeTheta(
          pixiMap.globalToRos(e.data.global.x, e.data.global.y)
        );
      }
      // 安全区域创建编辑开启
      if (pixiMap.changeSafety) {
        if (pixiMap.lastClick) {
          if (timeInterval - pixiMap.lastClick < 500) {
            // 双击时间小于500毫秒 触发
            pixiMap.creationArea(
              pixiMap.globalToRos(e.data.global.x, e.data.global.y)
            );
          }
        }
        pixiMap.lastClick = timeInterval;
      }
      // 点位重定位开启中
      if (pixiMap.pointLocation) {
        if (pixiMap.lastClick) {
          if (timeInterval - pixiMap.lastClick < 500) {
            // 双击时间小于500毫秒 触发
            pixiMap.changePoint(
              pixiMap.globalToRos(e.data.global.x, e.data.global.y)
            );
          }
        }
        pixiMap.lastClick = timeInterval;
      }
      // 点位重定方向开启中
      if (pixiMap.changePointDirection) {
        pixiMap.PointDirection(
          pixiMap.globalToRos(e.data.global.x, e.data.global.y)
        );
      }
      // 远程点位创建开启
      if (pixiMap.pointOpen) {
        if (pixiMap.lastClick) {
          if (timeInterval - pixiMap.lastClick < 500) {
            // 双击时间小于500毫秒 触发
            pixiMap.creationPoint(
              pixiMap.globalToRos(e.data.global.x, e.data.global.y)
            );
          }
        }
        pixiMap.lastClick = timeInterval;
      }
    });
    app.stage.on("pointerup", () => {
      pixiMap.stageMove = false;
    });
    app.stage.on("pointermove", (e) => {
      // 判断鼠标是否超出画布范围
      if (
        e.data.global.y > 0 &&
        e.data.global.y < height &&
        e.data.global.x > 0 &&
        e.data.global.x < width
      ) {
        // 判断地图是否允许拖动
        if (pixiMap.stageMove) {
          app.stage.x = e.data.global.x + startPointX;
          app.stage.y = e.data.global.y + startPointY;
        }
      } else {
        pixiMap.stageMove = false;
      }
    });
    app.stage.on("mouseout", () => {
      pixiMap.stageMove = false;
    });
    app.stage.onwheel = (e) => {
      pixiMap.zoom(e.deltaY);
    };
    return app.stage;
  };

  pixiMap.destroyStage = () => {
    app.destroy(true, true);
  };

  /**
   * 初始化所有对象
   */
  pixiMap.initStage = () => {
    pixiMap.lineContainer = new PIXI.Container();
    pixiMap.pointContainer = new PIXI.Container();
    pixiMap.deadContainer = new PIXI.Container();
    pixiMap.safetyContainer = new PIXI.Container();
    pixiMap.wallContainer = new PIXI.Container();
    pixiMap.robContainer = new PIXI.Container();
    pixiMap.scanContainer = new PIXI.Container();
    pixiMap.robot = new PIXI.Sprite();
  };

  /**
   * 展示舞台内所有元素
   * 将舞台居中进行适配放大
   * 展示地图、机器人及路线
   */
  pixiMap.updateStage = () => {
    let W = 10;
    let H = 10;
    if (pixiMap.div.height > pixiMap.div.width) {
      H = (W * pixiMap.div.offsetHeight) / pixiMap.div.offsetWidth;
    } else {
      W = (H * pixiMap.div.offsetWidth) / pixiMap.div.offsetHeight;
    }
    pixiMap.stage.scale.set(
      pixiMap.div.offsetWidth / W,
      pixiMap.div.offsetHeight / H
    );
    shiftStage(-W / 2, -H / 2);
    pixiMap.stage.removeChildren();
    pixiMap.stage.addChild(pixiMap.map);
    pixiMap.stage.addChild(pixiMap.lineContainer || new PIXI.Container());
    pixiMap.stage.addChild(pixiMap.pointContainer || new PIXI.Container());
    pixiMap.stage.addChild(pixiMap.deadContainer || new PIXI.Container());
    pixiMap.stage.addChild(pixiMap.safetyContainer || new PIXI.Container());
    pixiMap.stage.addChild(pixiMap.wallContainer || new PIXI.Container());
    pixiMap.stage.addChild(pixiMap.robContainer || new PIXI.Container());
    pixiMap.stage.addChild(pixiMap.scanContainer || new PIXI.Container());
    pixiMap.stage.addChild(pixiMap.robot || new PIXI.Sprite());
  };

  /**
   * 创建地图
   * @param options ：
   *    * data - 地图数据
   *    * img - 地图图片
   * @returns {*} 地图对象，pixijs的精灵
   * @constructor
   */
  pixiMap.createMap = (options) => {
    options = options || {};
    const map = PIXI.Sprite.from(options.img);
    // 改变Y轴中心
    map.y = -map.height * options.resolution;
    // 按像素比每米进行缩小画布
    map.scale.set(options.resolution);

    // 设置位置
    map.x += options.x;
    map.y -= options.y;
    // 清理地图缓存
    PIXI.utils.clearTextureCache();
    return map;
  };

  /**
   * 绘制地图中代表机器人的箭头
   * @param options ：
   *    * image - 机器人图片
   *    * alpha - 透明度
   * @returns {*} 机器人对象，pixijs的精灵
   * @constructor
   */
  pixiMap.createRobot = (options) => {
    options = options || {};
    pixiMap.robotPic = options.image;
    const size = 1;
    const alpha = options.alpha || 1;
    const robot = PIXI.Sprite.from(options.image);
    const scale = size / options.image.width;
    robot.alpha = alpha;
    robot.scale.set(scale);
    robot.anchor.set(0.5); // 图片中心为原点，而不是左上角
    robot.tint = "0x1E90FF";
    return robot;
  };

  /**
   * 更新机器人位置
   * @param pos 机器人ros点位
   */
  pixiMap.updateRobot = function (pos) {
    pixiMap.robot.x = pos.position.x;
    pixiMap.robot.y = -pos.position.y;
    // pixijs用的是弧度制，角度转弧度
    pixiMap.robot.rotation =
      ((90 + pixiMap.toTheta(pos.orientation)) * Math.PI) / 180;
    if (pixiMap.viewLocking) {
      // 视角锁定
      pixiMap.focus();
    }
  };

  /**
   * 视角锁定（聚焦机器人位置）
   */
  pixiMap.focus = () => {
    pixiMap.stage.x = pixiMap.div.offsetWidth / 2;
    pixiMap.stage.y = pixiMap.div.offsetHeight / 2;
    shiftStage(pixiMap.robot.x, -pixiMap.robot.y);
  };

  /**
   * 绘制虚拟墙
   * @param list 虚拟墙列表
   */
  pixiMap.drawWall = function (list) {
    if (list) pixiMap.savedWall = list;
    if (!pixiMap.savedWall) return;
    pixiMap.wallContainer.removeChildren();
    pixiMap.savedWall.forEach((wall) => {
      pixiMap.wallContainer.addChild(pixiMap.createWall(wall));
    });
  };

  /**
   * 创建虚拟墙
   * @param wall 虚拟墙数据
   * @returns {Graphics} 虚拟墙对象
   */
  pixiMap.createWall = (wall) => {
    const line = new PIXI.Graphics();
    line.name = wall.id;
    pixiMap.editWall(
      line,
      { x: wall.startX, y: wall.startY },
      { x: wall.endX, y: wall.endY }
    );
    return line;
  };

  /**
   * 编辑虚拟墙
   * @param line 虚拟墙对象
   * @param startPoint 起始端点
   * @param endPoint 末端点
   */
  pixiMap.editWall = (line, startPoint, endPoint) => {
    line.clear();
    line.lineStyle(pixiMap.wallSize, pixiMap.wallColor, 0.5);
    line.moveTo(startPoint.x, -startPoint.y);
    line.lineTo(endPoint.x, -endPoint.y);
  };

  /**
   * 绘制按钮
   * @param options
   * @returns {Sprite}
   */
  pixiMap.createBtn = (options) => {
    options = options || {};
    const size = 0.4;
    const alpha = options.alpha || 0.5;

    const btn = PIXI.Sprite.from(options.image);
    btn.anchor.set(0.5); // 图片中心为原点，而不是左上角
    btn.tint = pixiMap.wallColor;
    btn.alpha = alpha;
    const scale = size / options.image.width;
    btn.scale.set(scale);
    btn.interactive = true;
    return btn;
  };

  /**
   * 清空路线
   */
  pixiMap.clearRail = () => {
    pixiMap.pointContainer.removeChildren();
    pixiMap.lineContainer.removeChildren();
  };

  /**
   * 画路线
   * @param list 点位列表
   */
  pixiMap.drawRail = function (list) {
    // savedList为最近一次的list，当函数传参为空是即画最近一次的路线
    if (list) pixiMap.savedList = list;
    if (!pixiMap.savedList) return;
    pixiMap.clearRail();
    const m = new Map();
    pixiMap.savedList.forEach((v) => {
      m.set(v.id, v.pose);
    });
    pixiMap.savedList.forEach((point) => {
      if (pixiMap.highlight_id === point.id) {
        pixiMap.pointSize = 0.8;
        pixiMap.pointColor = pixiMap.mode === "loop" ? "0x9898E3" : "0xFF6666"; // 点位高亮颜色
      } else {
        pixiMap.pointSize = 0.5;
        pixiMap.pointColor = pixiMap.mode === "loop" ? "0x32CD32" : "0x9370DB"; // 点位颜色
      }
      pixiMap.pointContainer.addChild(createPoint(point));
      point.connectedPose = point.connectedPose || [];
      point.connectedPose.forEach((p) => {
        if (!m.get(p)) return; // 连接点中的跨地图点直接return，不进行连线
        pixiMap.lineContainer.addChild(
          createLine(point.pose.position, m.get(p).position)
        );
      });
    });
  };

  /**
   * 创建线
   * @param startPoint 起点坐标
   * @param endPoint 终点坐标
   * @returns {PIXI.Graphics} 线对象（pixijs的精灵）
   */
  function createLine(startPoint, endPoint) {
    const line = new PIXI.Graphics();
    editLine(line, startPoint, endPoint);
    return line;
  }

  /**
   * 编辑线
   * @param line 线对象
   * @param startPoint 起点坐标
   * @param endPoint 终点坐标
   */
  function editLine(line, startPoint, endPoint) {
    line.clear();
    line.lineStyle(pixiMap.lineSize, pixiMap.lineColor, 0.5);
    line.moveTo(startPoint.x, -startPoint.y);
    line.lineTo(endPoint.x, -endPoint.y);
  }

  /**
   * 点位显示高亮
   * @param id 高亮点位id
   */
  pixiMap.highlight = function (id) {
    pixiMap.highlight_id = id;
    pixiMap.drawRail();
  };

  /**
   * 创建点
   * @param p 点对象
   * @returns {Sprite} 点对象（pixijs的精灵）
   */
  function createPoint(p) {
    const pos = p.pose || p;
    const point = PIXI.Sprite.from(pixiMap.poseImg);
    point.anchor.set(0.5);
    point.tint = pixiMap.pointColor;
    point.alpha = 0.66; // 透明度
    const scale = pixiMap.pointSize / pixiMap.poseImg.width;
    point.scale.set(scale);
    point.x = pos.position.x;
    point.y = -pos.position.y;
    point.rotation = ((90 + pixiMap.toTheta(pos.orientation)) * Math.PI) / 180;
    point.name = p.id;
    point.interactive = true;
    point.on("pointerdown", () => {
      // 判断符合这些条件才可以查看点位信息
      if (
        pixiMap.changeSafety ||
        pixiMap.changeDirection ||
        pixiMap.changeLocation ||
        pixiMap.pointLocation ||
        pixiMap.changePointDirection ||
        pixiMap.pointOpen ||
        pixiMap.mapFormat === "landmark"
      )
        return;
      pixiMap.checkPoint(p);
    });
    return point;
  }

  /**
   * 计算角度
   * @param orientation 角度参数
   * @returns {number} 弧度
   */
  pixiMap.toTheta = (orientation) => {
    const q0 = orientation.w;
    const q1 = orientation.x;
    const q2 = orientation.y;
    const q3 = orientation.z;
    // Canvas rotation is clock wise and in degrees
    return (
      (-Math.atan2(2 * (q0 * q3 + q1 * q2), 1 - 2 * (q2 * q2 + q3 * q3)) *
        180.0) /
      Math.PI
    );
  };

  /**
   * 缩放
   * @param dir 正数为放大，负数为缩小
   * @param x
   * @param y
   */
  pixiMap.zoom = function (dir, x, y) {
    if (!x || !y) {
      x = pixiMap.div.offsetWidth / 2;
      y = pixiMap.div.offsetHeight / 2;
    }
    const center = {};
    const startShift = {};
    const startScale = {};
    center.x = x;
    center.y = y;
    startShift.x = pixiMap.stage.x;
    startShift.y = pixiMap.stage.y;
    startScale.x = pixiMap.stage.scale.x;
    startScale.y = pixiMap.stage.scale.y;
    let zoom;
    if (dir > 0) {
      zoom = 1.1;
    }
    if (dir < 0) {
      zoom = 0.9;
    }
    if (startScale.x * zoom < 10) {
      zoom = 10 / startScale.x;
    }
    if (startScale.x * zoom > 140) {
      zoom = 140 / startScale.x;
    }
    pixiMap.stage.scale.set(startScale.x * zoom);
    pixiMap.stage.x =
      startShift.x -
      (center.x - startShift.x) * (pixiMap.stage.scale.x / startScale.x - 1);
    pixiMap.stage.y =
      startShift.y -
      (center.y - startShift.y) * (pixiMap.stage.scale.y / startScale.y - 1);
  };

  /**
   * 对焦
   * @param pos 焦点点位
   */
  pixiMap.lookAt = (pos) => {
    pixiMap.stage.x = pixiMap.div.offsetWidth / 2;
    pixiMap.stage.y = pixiMap.div.offsetHeight / 2;
    shiftStage(pos.x, pos.y);
  };

  /**
   * 通过缩放所需偏移来移动场景
   * @param x ros坐标系的水平偏移量
   * @param y ros坐标系的垂直偏移量
   */
  function shiftStage(x, y) {
    pixiMap.stage.x -= x * pixiMap.stage.scale.x;
    pixiMap.stage.y += y * pixiMap.stage.scale.y;
  }

  /**
   * 全局坐标转ros坐标
   * @param x 全局水平坐标
   * @param y 全局垂直坐标
   */
  pixiMap.globalToRos = (x, y) => {
    const rosX = (x - pixiMap.stage.x) / pixiMap.stage.scale.x;
    const rosY = (pixiMap.stage.y - y) / pixiMap.stage.scale.y;
    return { x: rosX, y: rosY };
  };

  /**
   * 获取屏幕正中心的ros坐标
   */
  pixiMap.centerRos = () => {
    const rosX =
      (pixiMap.div.offsetWidth / 2 - pixiMap.stage.x) / pixiMap.stage.scale.x;
    const rosY =
      (pixiMap.stage.y - pixiMap.div.offsetHeight / 2) / pixiMap.stage.scale.y;
    return {
      x: rosX,
      y: rosY,
    };
  };
  /**
   * 创建安全区线
   * @returns {PIXI.Graphics} 线对象（pixijs的精灵）
   */
  pixiMap.createSafetyLine = () => {
    // 判断是否为空
    console.log(pixiMap.path);
    if (pixiMap.path.length % 2 === 0) {
      // 每次重新画
      pixiMap.duobian.clear();
      // 安全区线路的颜色宽度
      pixiMap.duobian.lineStyle(0.1, "0xFF3300", 0.5);
      // 画线
      pixiMap.duobian.drawPolygon(pixiMap.path);
      // 结束
      pixiMap.duobian.endFill();
      // 创建线
      pixiMap.lineContainer.addChild(pixiMap.duobian);
    }
  };
  /**
   * 加载安全区画线
   */
  pixiMap.drawSafety = function (list) {
    if (list) pixiMap.saveSafety = list;
    pixiMap.safetyContainer.removeChildren();
    pixiMap.saveSafety.forEach((safety) => {
      pixiMap.safetyContainer.addChild(pixiMap.createSafety(safety));
      pixiMap.safetyContainer.addChild(creationText(safety));
    });
  };

  /**
   * 创建安全区线
   * @param safety 安全区数据{}
   * @returns {Graphics} 安全区对象
   */
  pixiMap.createSafety = (safety) => {
    const lines = new PIXI.Graphics();
    const p = [];
    // 循环获取点位坐标
    safety.polygon.forEach((item) => {
      p.push(item.x, item.y);
    });
    lines.lineStyle(0.1, "0xFF3300", 0.5);
    lines.drawPolygon(p);
    lines.name = safety.id;
    // 结束
    lines.endFill();
    pixiMap.linesList.push(lines);
    return lines;
  };
  /**
   * 创建安全区的点
   */
  pixiMap.safetyDot = (p) => {
    // 编辑完后点位颜色
    if (pixiMap.dots) {
      pixiMap.dots.tint = "0x98FB98";
    }
    // 点图片
    const dot = PIXI.Sprite.from("dot.png");
    dot.anchor.set(0.5);
    // 颜色
    dot.tint = "0x008000";
    // 大小
    const scale = 0.04 / 44;
    dot.scale.set(scale);
    dot.x = p[0];
    // 判断是否是开启了编辑模式
    if (pixiMap.safetyState) {
      dot.y = p[1];
    } else {
      dot.y = -p[1];
    }
    pixiMap.dots = dot;
    // 创建精灵
    pixiMap.safetyContainer.addChild(dot);
    // 储存点对象精灵
    pixiMap.dotList.push(dot);
    // return dot
  };

  /**
   * 安全区的名字
   */
  function creationText(p) {
    const richText = new PIXI.Text(p.name);
    let x = 0;
    let y = 0;
    p.polygon.forEach((item) => {
      x += item.x;
      y += -item.y;
    });
    richText.x = x / p.polygon.length - 0.2;
    richText.y = y / p.polygon.length;
    const scale = 0.2 / 44;
    richText.scale.set(scale);
    return richText;
  }

  /**
   * 画死锁点
   */
  pixiMap.drawDead = function () {
    pixiMap.deadContainer.removeChildren();
    pixiMap.savedList.forEach((dead) => {
      if (pixiMap.lockList.includes(dead.id)) {
        pixiMap.deadContainer.addChild(createLockPoint(dead));
      }
    });
  };

  /**
   * 创建死锁点位
   */
  function createLockPoint(p) {
    const pos = p.pose;
    const deadly = PIXI.Sprite.from("map/deadly.png");
    deadly.anchor.set(0.5);
    deadly.tint = "0xe46161";
    deadly.alpha = 1; // 透明度
    const scale = 0.1 / 44;
    deadly.scale.set(scale);
    deadly.x = pos.position.x;
    deadly.y = -pos.position.y;
    deadly.name = p.id;
    return deadly;
  }

  /**
   * 算出开始的俩距离
   * @param a 第一个点坐标
   * @param b 第二个点坐标
   * @returns {number} 2点之间的距离
   */
  function getDistance(a, b) {
    const x = a.clientX - b.clientX;
    const y = a.clientY - b.clientY;
    return Math.hypot(x, y);
  }

  /**
   * 绘制激光雷达
   * @param list 激光线段 (将数组内的点按顺序连接，遇到参数z不为0的进行断开)
   */
  pixiMap.drawScan = (list) => {
    if (list) pixiMap.savedScan = list;
    if (!pixiMap.savedScan) return;
    // 清空容器
    pixiMap.scanContainer.removeChildren();
    let tempLine; // 缓存线段
    pixiMap.savedScan.forEach((p, index) => {
      if (tempLine) {
        // 有缓存线段
        if (p.z === 0) {
          // 如果点的z为0，则缓存线段进行连接
          tempLine.lineTo(p.x, -p.y);
          if (index === pixiMap.savedScan.length - 1) {
            // 如果连的是最后一个点，则进行渲染并清空
            pixiMap.scanContainer.addChild(tempLine);
            tempLine = null;
          }
        } else {
          // 如果点的z不为0，则将缓存线段进行渲染，并清空缓存线段
          pixiMap.scanContainer.addChild(tempLine);
          tempLine = null;
        }
      } else {
        // 没有缓存线段
        tempLine = new PIXI.Graphics(); // 创建
        tempLine.clear();
        tempLine.lineStyle(pixiMap.lineSize, pixiMap.scanColor, 0.5); // 线段赋予样式
        tempLine.moveTo(p.x, -p.y); // 线段设起点
      }
    });
  };

  return pixiMap;
}
